package docextractor

import (
	"net"
	"os"
	"runtime"
	"strings"
	"time"

	"github.com/enriquebris/goconcurrentqueue"

	"gitee.com/guoliben/kydlp-doctotext/utils/ctrlledprint"
	"gitee.com/guoliben/kydlp-doctotext/3rdparty/fileidentify"
	"gitee.com/guoliben/kydlp-doctotext/extractor_interface"
)

func TextExtractorFactory(filetype string) extractor_interface.TextExtractor {
	switch strings.TrimSpace(filetype) {

	case fileidentify.DocTypeText:
		return DocText{}

	case fileidentify.DocTypeHtml:
		return DocHtml{}

	case fileidentify.DocTypeXml:
		return DocXml{}

	case fileidentify.DocTypeJson:
		return DocJson{}

	case fileidentify.DocTypePdf:
		return DocPdf{}

	case fileidentify.DocTypeMsDoc:
		return DocOleStorage{}

	case fileidentify.DocTypeMsDocx:
		return DocWordX{}

	case fileidentify.DocTypeMsXls:
		return DocExcel{}

	case fileidentify.DocTypeMsXlsx:
		return DocExcelX{}

	case fileidentify.DocTypeMsPpt:
		return DocPpt{}

	case fileidentify.DocTypeMsPptx:
		return DocPptX{}
	}
	return extractor_interface.UnknownType{}
}

var multiProcessMode bool = false

type DocumentFileTask struct {
	FilePath string
	FileSize int64
	FileType string
}

type DocumentBufferTask struct {
	FileContent []byte
	FileSize int64
	FileType string
}

var (
	maxSizeOfTaskQueue = (runtime.NumCPU() + 3) / 4

	useFIFO = true
	PdfBufferTaskQueue goconcurrentqueue.Queue
	OleBufferTaskQueue goconcurrentqueue.Queue
	DocXBufferTaskQueue goconcurrentqueue.Queue
	XlsBufferTaskQueue goconcurrentqueue.Queue
	XlsXBufferTaskQueue goconcurrentqueue.Queue
	PptBufferTaskQueue goconcurrentqueue.Queue
	PptXBufferTaskQueue goconcurrentqueue.Queue
	//TextBufferTaskQueue goconcurrentqueue.Queue
	//HtmlBufferTaskQueue goconcurrentqueue.Queue
	//JsonBufferTaskQueue goconcurrentqueue.Queue
	//XmlBufferTaskQueue goconcurrentqueue.Queue

	unixSocketPath = "/opt/kydlp-control-discovery/sock/document-ipc.sock"
	listener net.Listener
)

func Init() error {
	value := os.Getenv("USE_MULTIPROCESS_MODE")
	if len(value) > 0 {
		value = strings.ToLower(strings.TrimSpace(value))
		switch value {
		case "true", "1", "yes", "on":
			multiProcessMode = true
		case "false", "0", "no", "off":
			multiProcessMode = false
		default:
			multiProcessMode = false
		}
	} else {
		multiProcessMode = false
	}

	if multiProcessMode {
		if PdfBufferTaskQueue == nil {
			if useFIFO {
				PdfBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				PdfBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if PdfBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建PDF(buffer)文档任务队列成功!", "任务队列初始容量:", PdfBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建PDF(buffer)文档任务队列失败!")
				return nil
			}
		}
		if OleBufferTaskQueue == nil {
			if useFIFO {
				OleBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				OleBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if OleBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建OLE(buffer)文档任务队列成功!", "任务队列初始容量:", OleBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建OLE(buffer)文档任务队列失败!")
				return nil
			}
		}
		if DocXBufferTaskQueue == nil {
			if useFIFO {
				DocXBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				DocXBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if DocXBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建DOCX(buffer)文档任务队列成功!", "任务队列初始容量:", DocXBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建DOCX(buffer)文档任务队列失败!")
				return nil
			}
		}
		if XlsBufferTaskQueue == nil {
			if useFIFO {
				XlsBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				XlsBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if XlsBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建XLS(buffer)文档任务队列成功!", "任务队列初始容量:", XlsBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建XLS(buffer)文档任务队列失败!")
				return nil
			}
		}
		if XlsXBufferTaskQueue == nil {
			if useFIFO {
				XlsXBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				XlsXBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if XlsXBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建XLSX(buffer)文档任务队列成功!", "任务队列初始容量:", XlsXBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建XLSX(buffer)文档任务队列失败!")
				return nil
			}
		}
		if PptBufferTaskQueue == nil {
			if useFIFO {
				PptBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				PptBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if PptBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建PPT(buffer)文档任务队列成功!", "任务队列初始容量:", PptBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建PPT(buffer)文档任务队列失败!")
				return nil
			}
		}
		if PptXBufferTaskQueue == nil {
			if useFIFO {
				PptXBufferTaskQueue = goconcurrentqueue.NewFIFO()
			} else {
				PptXBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
			}
			if PptXBufferTaskQueue != nil {
				ctrlledprint.Println("\t创建PPTX(buffer)文档任务队列成功!", "任务队列初始容量:", PptXBufferTaskQueue.GetCap())
			} else {
				ctrlledprint.Println("\t创建PPTX(buffer)文档任务队列失败!")
				return nil
			}
		}
		//if TextBufferTaskQueue == nil {
		//	if useFIFO {
		//		TextBufferTaskQueue = goconcurrentqueue.NewFIFO()
		//	} else {
		//		TextBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
		//	}
		//	if TextBufferTaskQueue != nil {
		//		ctrlledprint.Println("\t创建TEXT(buffer)文档任务队列成功!", "任务队列初始容量:", TextBufferTaskQueue.GetCap())
		//	} else {
		//		ctrlledprint.Println("\t创建TEXT(buffer)文档任务队列失败!")
		//		return nil
		//	}
		//}
		//if HtmlBufferTaskQueue == nil {
		//	if useFIFO {
		//		HtmlBufferTaskQueue = goconcurrentqueue.NewFIFO()
		//	} else {
		//		HtmlBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
		//	}
		//	if HtmlBufferTaskQueue != nil {
		//		ctrlledprint.Println("\t创建HTML(buffer)文档任务队列成功!", "任务队列初始容量:", HtmlBufferTaskQueue.GetCap())
		//	} else {
		//		ctrlledprint.Println("\t创建HTML(buffer)文档任务队列失败!")
		//		return nil
		//	}
		//}
		//if JsonBufferTaskQueue == nil {
		//	if useFIFO {
		//		JsonBufferTaskQueue = goconcurrentqueue.NewFIFO()
		//	} else {
		//		JsonBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
		//	}
		//	if JsonBufferTaskQueue != nil {
		//		ctrlledprint.Println("\t创建JSON(buffer)文档任务队列成功!", "任务队列初始容量:", JsonBufferTaskQueue.GetCap())
		//	} else {
		//		ctrlledprint.Println("\t创建JSON(buffer)文档任务队列失败!")
		//		return nil
		//	}
		//}
		//if XmlBufferTaskQueue == nil {
		//	if useFIFO {
		//		XmlBufferTaskQueue = goconcurrentqueue.NewFIFO()
		//	} else {
		//		XmlBufferTaskQueue = goconcurrentqueue.NewFixedFIFO(maxSizeOfTaskQueue)
		//	}
		//	if XmlBufferTaskQueue != nil {
		//		ctrlledprint.Println("\t创建XML(buffer)文档任务队列成功!", "任务队列初始容量:", XmlBufferTaskQueue.GetCap())
		//	} else {
		//		ctrlledprint.Println("\t创建XML(buffer)文档任务队列失败!")
		//		return nil
		//	}
		//}

		go createTaskTransferServer()
	}

	return nil
}

func Destroy() {
	if multiProcessMode {
		if PdfBufferTaskQueue != nil {
			ctrlledprint.Println("PDF(buffer)文档任务队列容量:", PdfBufferTaskQueue.GetCap(), "已经入队的任务数:", PdfBufferTaskQueue.GetLen())
		}
		if OleBufferTaskQueue != nil {
			ctrlledprint.Println("OLE(buffer)文档任务队列容量:", OleBufferTaskQueue.GetCap(), "已经入队的任务数:", OleBufferTaskQueue.GetLen())
		}
		if DocXBufferTaskQueue != nil {
			ctrlledprint.Println("DOCX(buffer)文档任务队列容量:", DocXBufferTaskQueue.GetCap(), "已经入队的任务数:", DocXBufferTaskQueue.GetLen())
		}
		if XlsBufferTaskQueue != nil {
			ctrlledprint.Println("XLS(buffer)文档任务队列容量:", XlsBufferTaskQueue.GetCap(), "已经入队的任务数:", XlsBufferTaskQueue.GetLen())
		}
		if XlsXBufferTaskQueue != nil {
			ctrlledprint.Println("XLSX(buffer)文档任务队列容量:", XlsXBufferTaskQueue.GetCap(), "已经入队的任务数:", XlsXBufferTaskQueue.GetLen())
		}
		if PptBufferTaskQueue != nil {
			ctrlledprint.Println("PPT(buffer)文档任务队列容量:", PptBufferTaskQueue.GetCap(), "已经入队的任务数:", PptBufferTaskQueue.GetLen())
		}
		if PptXBufferTaskQueue != nil {
			ctrlledprint.Println("PPTX(buffer)文档任务队列容量:", PptXBufferTaskQueue.GetCap(), "已经入队的任务数:", PptXBufferTaskQueue.GetLen())
		}
		//if TextBufferTaskQueue != nil {
		//	ctrlledprint.Println("TEXT(buffer)文档任务队列容量:", TextBufferTaskQueue.GetCap(), "已经入队的任务数:", TextBufferTaskQueue.GetLen())
		//}
		//if HtmlBufferTaskQueue != nil {
		//	ctrlledprint.Println("HTML(buffer)文档任务队列容量:", HtmlBufferTaskQueue.GetCap(), "已经入队的任务数:", HtmlBufferTaskQueue.GetLen())
		//}
		//if JsonBufferTaskQueue != nil {
		//	ctrlledprint.Println("JSON(buffer)文档任务队列容量:", JsonBufferTaskQueue.GetCap(), "已经入队的任务数:", JsonBufferTaskQueue.GetLen())
		//}
		//if XmlBufferTaskQueue != nil {
		//	ctrlledprint.Println("XML(buffer)文档任务队列容量:", XmlBufferTaskQueue.GetCap(), "已经入队的任务数:", XmlBufferTaskQueue.GetLen())
		//}
		if listener != nil {
			ctrlledprint.Println("关闭文档任务传输服务端监听器")
			defer listener.Close() // 关闭后在调用listener.Accept会异常退出！
		}
	}
}

func createTaskTransferServer() {
	if listener == nil {
		// 删除旧的本地套接字文件
		err := os.Remove(unixSocketPath)
		if err != nil && !os.IsNotExist(err) {
			ctrlledprint.Println("\t删除旧的套接字文件出错:", err)
		}
		// 创建Unix域套接字
		listener, err = net.Listen("unix", unixSocketPath)
		if err != nil {
			ctrlledprint.Println("\t创建文档任务传输服务端监听器出错:", err)
			return
		} else {
			ctrlledprint.Println("\t创建文档任务传输服务端监听器成功!", "Listening on:", unixSocketPath)
		}
		for {
			// 接受客户端连接
			conn, err := listener.Accept()
			if err != nil {
				ctrlledprint.Println("\t服务器端退出或接收客户端连接出错:", err)
				break
			} else {
				// 打印客户端的地址
				ctrlledprint.Println("\t服务器端接收客户端连接成功!", "连接来自:", conn.RemoteAddr().String())
			}

			// 处理连接
			go handleConnection(conn)
		}
	}
}

func handleConnection(conn net.Conn) {
	defer conn.Close()

	// 读取客户端发来的任务类型
	var tasktype string
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		ctrlledprint.Println("接收任务传输客户端发来的\"任务类型\"出错:", err)
		return
	} else {
		tasktype = string(buffer[:n])
		ctrlledprint.Println("接收任务传输客户端发来的\"任务类型\":", tasktype)
	}
	time.Sleep(10 * time.Millisecond)

	if n == len("pdftask") && tasktype == "pdftask" {
		// 从PDF文档任务队列取出一个任务，并向客户端发送该任务
		if PdfBufferTaskQueue != nil {
			ctrlledprint.Println("<--- PDF(buffer)文档任务队列容量:", PdfBufferTaskQueue.GetCap(), "已经入队的任务数:", PdfBufferTaskQueue.GetLen())
			task, err := PdfBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("PDF(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("PDF(buffer)文档任务出队成功!")
			}
			pdfbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(pdfbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("PDF(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("PDF(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("olestoragetask") && tasktype == "olestoragetask" {
		// 从OLE文档任务队列取出一个任务，并向客户端发送该任务
		if OleBufferTaskQueue != nil {
			ctrlledprint.Println("<--- OLE(buffer)文档任务队列容量:", OleBufferTaskQueue.GetCap(), "已经入队的任务数:", OleBufferTaskQueue.GetLen())
			task, err := OleBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("OLE(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("OLE(buffer)文档任务出队成功!")
			}
			olebuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(olebuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("OLE(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("OLE(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("docxtask") && tasktype == "docxtask" {
		if DocXBufferTaskQueue != nil {
			ctrlledprint.Println("<--- DOCX(buffer)文档任务队列容量:", DocXBufferTaskQueue.GetCap(), "已经入队的任务数:", DocXBufferTaskQueue.GetLen())
			task, err := DocXBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("DOCX(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("DOCX(buffer)文档任务出队成功!")
			}
			docxbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(docxbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("DOCX(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("DOCX(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("xlstask") && tasktype == "xlstask" {
		// 从XLS文档任务队列取出一个任务，并向客户端发送该任务
		if XlsBufferTaskQueue != nil {
			ctrlledprint.Println("<--- XLS(buffer)文档任务队列容量:", XlsBufferTaskQueue.GetCap(), "已经入队的任务数:", XlsBufferTaskQueue.GetLen())
			task, err := XlsBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("XLS(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("XLS(buffer)文档任务出队成功!")
			}
			xlsbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(xlsbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("XLS(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("XLS(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("xlsxtask") && tasktype == "xlsxtask" {
		if XlsXBufferTaskQueue != nil {
			ctrlledprint.Println("<--- XLSX(buffer)文档任务队列容量:", XlsXBufferTaskQueue.GetCap(), "已经入队的任务数:", XlsXBufferTaskQueue.GetLen())
			task, err := XlsXBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("XLSX(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("XLSX(buffer)文档任务出队成功!")
			}
			xlsxbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(xlsxbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("XLSX(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("XLSX(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("ppttask") && tasktype == "ppttask" {
		if PptBufferTaskQueue != nil {
			ctrlledprint.Println("<--- PPT(buffer)文档任务队列容量:", PptBufferTaskQueue.GetCap(), "已经入队的任务数:", PptBufferTaskQueue.GetLen())
			task, err := PptBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("PPT(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("PPT(buffer)文档任务出队成功!")
			}
			pptbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(pptbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("PPT(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("PPT(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	} else if n == len("pptxtask") && tasktype == "pptxtask" {
		if PptXBufferTaskQueue != nil {
			ctrlledprint.Println("<--- PPTX(buffer)文档任务队列容量:", PptXBufferTaskQueue.GetCap(), "已经入队的任务数:", PptXBufferTaskQueue.GetLen())
			task, err := PptXBufferTaskQueue.Dequeue()
			if err != nil {
				ctrlledprint.Println("PPTX(buffer)文档任务出队失败:", err)
				return
			} else {
				ctrlledprint.Println("PPTX(buffer)文档任务出队成功!")
			}
			pptxbuffertask := task.(DocumentBufferTask)

			start := time.Now()
			n, err := conn.Write(pptxbuffertask.FileContent)
			if err != nil {
				ctrlledprint.Println("PPTX(buffer)文档任务传输出错:", err)
				return
			}
			elapsed := time.Since(start)

			ctrlledprint.Println("PPTX(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
		}
	//} else if n == len("texttask") && tasktype == "texttask" {
	//	if TextBufferTaskQueue != nil {
	//		ctrlledprint.Println("<--- TEXT(buffer)文档任务队列容量:", TextBufferTaskQueue.GetCap(), "已经入队的任务数:", TextBufferTaskQueue.GetLen())
	//		task, err := TextBufferTaskQueue.Dequeue()
	//		if err != nil {
	//			ctrlledprint.Println("TEXT(buffer)文档任务出队失败:", err)
	//			return
	//		} else {
	//			ctrlledprint.Println("TEXT(buffer)文档任务出队成功!")
	//		}
	//		textbuffertask := task.(DocumentBufferTask)

	//		start := time.Now()
	//		n, err := conn.Write(textbuffertask.FileContent)
	//		if err != nil {
	//			ctrlledprint.Println("TEXT(buffer)文档任务传输出错:", err)
	//			return
	//		}
	//		elapsed := time.Since(start)

	//		ctrlledprint.Println("TEXT(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
	//	}
	//} else if n == len("htmltask") && tasktype == "htmltask" {
	//	if HtmlBufferTaskQueue != nil {
	//		ctrlledprint.Println("<--- HTML(buffer)文档任务队列容量:", HtmlBufferTaskQueue.GetCap(), "已经入队的任务数:", HtmlBufferTaskQueue.GetLen())
	//		task, err := HtmlBufferTaskQueue.Dequeue()
	//		if err != nil {
	//			ctrlledprint.Println("HTML(buffer)文档任务出队失败:", err)
	//			return
	//		} else {
	//			ctrlledprint.Println("HTML(buffer)文档任务出队成功!")
	//		}
	//		htmlbuffertask := task.(DocumentBufferTask)

	//		start := time.Now()
	//		n, err := conn.Write(htmlbuffertask.FileContent)
	//		if err != nil {
	//			ctrlledprint.Println("HTML(buffer)文档任务传输出错:", err)
	//			return
	//		}
	//		elapsed := time.Since(start)

	//		ctrlledprint.Println("HTML(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
	//	}
	//} else if n == len("jsontask") && tasktype == "jsontask" {
	//	if JsonBufferTaskQueue != nil {
	//		ctrlledprint.Println("<--- JSON(buffer)文档任务队列容量:", JsonBufferTaskQueue.GetCap(), "已经入队的任务数:", JsonBufferTaskQueue.GetLen())
	//		task, err := JsonBufferTaskQueue.Dequeue()
	//		if err != nil {
	//			ctrlledprint.Println("JSON(buffer)文档任务出队失败:", err)
	//			return
	//		} else {
	//			ctrlledprint.Println("JSON(buffer)文档任务出队成功!")
	//		}
	//		jsonbuffertask := task.(DocumentBufferTask)

	//		start := time.Now()
	//		n, err := conn.Write(jsonbuffertask.FileContent)
	//		if err != nil {
	//			ctrlledprint.Println("JSON(buffer)文档任务传输出错:", err)
	//			return
	//		}
	//		elapsed := time.Since(start)

	//		ctrlledprint.Println("JSON(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
	//	}
	//} else if n == len("xmltask") && tasktype == "xmltask" {
	//	if XmlBufferTaskQueue != nil {
	//		ctrlledprint.Println("<--- XML(buffer)文档任务队列容量:", XmlBufferTaskQueue.GetCap(), "已经入队的任务数:", XmlBufferTaskQueue.GetLen())
	//		task, err := XmlBufferTaskQueue.Dequeue()
	//		if err != nil {
	//			ctrlledprint.Println("XML(buffer)文档任务出队失败:", err)
	//			return
	//		} else {
	//			ctrlledprint.Println("XML(buffer)文档任务出队成功!")
	//		}
	//		xmlbuffertask := task.(DocumentBufferTask)

	//		start := time.Now()
	//		n, err := conn.Write(xmlbuffertask.FileContent)
	//		if err != nil {
	//			ctrlledprint.Println("XML(buffer)文档任务传输出错:", err)
	//			return
	//		}
	//		elapsed := time.Since(start)

	//		ctrlledprint.Println("XML(buffer)文档任务传输完成!", "大小:", n, "耗时:", elapsed)
	//	}
	}
}
